package 泛型;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//例子1：
///**
// * 在java中，不能通过直接通过T[] tarr=new T[10]的方式来创建数组，最简单的方式便是通过Array.newInstance(Class<T> type,int size)的
// * 方式来创建数组。
// * 
// * 数组的工具
// *
// * @author David Day
// */
////public class ArrayUtils {
//public class 泛型数组 {
//
//	/**
//	 * 根据数组类型的class创建对应类型的数组
//	 *
//	 * @param <T>    目标类型
//	 * @param clazz
//	 * @param length 数组长度
//	 * @return
//	 */
//	public static <T> T[] newArrayByArrayClass(Class<T[]> clazz, int length) {
//		return (T[]) Array.newInstance(clazz.String[] byArray = newArrayByArrayClass(String[].class, 10);
//String[] byOne = newArrayByClass(String.class, 10);, length);
//	}
//
//	/**
//	 * 根据普通类型的class创建数组
//	 *
//	 * @param <T>    目标类型
//	 * @param clazz
//	 * @param length 数组长度
//	 * @return
//	 */
//	public static <T> T[] newArrayByClass(Class<T> clazz, int length) {
//		return (T[]) Array.newInstance(clazz, length);
//	}
//
//	public static void main(String[] args) {
//		// 判断一个Class是否是数组类型，可以用Class实例的isArray方法。
//		String[] byArray = newArrayByArrayClass(String[].class, 10);
//		String[] byOne = newArrayByClass(String.class, 10);
//
//		System.out.println(byArray.getClass().isArray());
//		System.out.println(byOne.getClass().isArray());
//	}
//}
/*
//例子2：
//创建泛型数组的关键类
class GenericsArray<T> {
	@SuppressWarnings({ "unchecked", "hiding" })
	public static <T>  T[] getArray(Class<T> componentType,int length) {
		return (T[]) Array.newInstance(componentType, length);
	}
}

//测试类
//public class TestGenericArray {
public class 泛型数组 {
	public static void main(String[] args) {
		@SuppressWarnings({ "static-access", "rawtypes" })
		Person[] persons = new GenericsArray().getArray(Person.class, 10);
		
		System.out.println(Arrays.toString(persons));
		for (int i = 0; i < persons.length; i++) {
			persons[i]=new Person(i);
		}
		System.out.println(Arrays.toString(persons));
	}
}
//Person类
class Person {
	private int id;
	public Person(int id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Person [id=" + id + "]";
	}
}
*/
/*
//例子3：
public class 泛型数组<T> {
   private T[] array;//拟定义的数组，数组成员为泛型类，可以是：Integer、String、Person
   @SuppressWarnings("unchecked")
   public 泛型数组(Class<T> type, int sz) {
      array = (T[])Array.newInstance(type, sz);//调用Array静态方法，生成数组实例
   }
   public void put(int index, T item) {
       array[index] = item;
   }
   public T get(int index) {
  	 return array[index]; 
   }
   public T[] rep() { 
  	 return array; 
   }
   public static void main(String[] args) {
       泛型数组<Integer> gai =new 泛型数组<Integer>(Integer.class, 10);//创建整型数组
       for(int i = 0; i < 10; i ++) {gai.put(i, i);}
       for(int i = 0; i < 10; i ++) {System.out.print(gai.get(i) + " ");}
       System.out.println();
       Integer[] ia = gai.rep();
       for(int i = 0; i < 10; i ++) {System.out.print(ia[i] + " ");}
       System.out.println();
       
       泛型数组<String> ga =new 泛型数组<String>(String.class, 10);//创建String型数组
       for(int i = 0; i < 10; i ++) {ga.put(i, String.valueOf(i));}
       for(int i = 0; i < 10; i ++) {System.out.print(gai.get(i) + " ");}
       System.out.println();
       String[] ias = ga.rep();
       for(int i = 0; i < 10; i ++) {System.out.print(ias[i] + " ");}
       System.out.println();
       
       泛型数组<Person> persons=new 泛型数组<Person>(Person.class, 4);//创建Person型数组
       persons.put(0, new Person(1, "张三"));
       persons.put(1, new Person(2, "李四"));
       persons.put(2, new Person(3, "王五"));
       for (int i=0;i<3;i++) System.out.println(persons.get(i));
       System.out.println();
       Person[] iap = persons.rep();
       for(int i = 0; i < 3; i ++) {System.out.print(iap[i] + " ");}
       System.out.println();
       
   }
}
class Person{
	Integer id;
	String name;

	public Person(Integer id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	public String toString() {
		return "[ id="+id+" name="+name+" ]";
	}
}
*/
/*
//例子4：
public class 泛型数组<T> {

	private Class<T> type;

	public 泛型数组(Class<T> type) {
		this.type = type;
	}

	@SuppressWarnings("unchecked")
	T[] createArray(int size) {
		return (T[]) Array.newInstance(type, size);
	}

	List<T> createList() {
		return new ArrayList<T>();
	}

	public static void main(String[] args) {
		泛型数组<Type> am2 = new 泛型数组<Type>(Type.class);
		System.out.println(Arrays.asList(am2.createArray(10)));
		System.out.println(Arrays.asList(am2.createList()));
	}
}

class Type {
	@Override
	public String toString() {
		return "type";
	}
}
*/
/*
//例子5：
class Genericn<T> {
}

public class 泛型数组 {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		Genericn<Integer>[] genArrI;
		genArrI = (Genericn<Integer>[]) new Genericn[2];
		
		Genericn<String>[] genArrS;
		genArrS = (Genericn<String>[]) new Genericn[2];
		System.out.println(genArrI.getClass().isArray());//true
		System.out.println(genArrS.getClass().isArray());//true
	}
}  
*/
//方法6、7：
public class 泛型数组 {
	public static void main(String[] args) {
		//例子6:
		class ArrayHelper {
		    @SafeVarargs
		    static <T> T[] asArray(T... objs) {
		        return objs;
		    }
		}
		String[] sss= {"a","b","c","d"};
		String[] ssss = ArrayHelper.asArray(sss);
		String[] ss = ArrayHelper.asArray("a", "b", "c");
		Integer[] ns = ArrayHelper.asArray(1, 2, 3);
		System.out.println(Arrays.toString(ss));
		System.out.println(Arrays.toString(ssss));
		//例子7:：
		class Abc<T>{
			@SuppressWarnings("unchecked")
			static <T> T[] createArray(Class<T> cls) {
				return (T[]) Array.newInstance(cls, 5);
			}
		}
		String[] st=Abc.createArray(String.class);
		Integer[] nu=Abc.createArray(Integer.class);
		st[0]="a";
		nu[0]=1;
		System.out.println(Arrays.toString(st));
		System.out.println(Arrays.toString(nu));
		
		//通过反射建立数组,两种方式：
		String[] byOneS = (String[]) Array.newInstance(String.class, 10);
		Integer[] byOneI = (Integer[]) Array.newInstance(Integer.class, 10);
		String[] byArrayS = (String[]) Array.newInstance(String[].class.getComponentType(), 10);//数组也是类
		Integer[] byArrayI = (Integer[]) Array.newInstance(Integer[].class.getComponentType(), 10);//数组也是类
		System.out.println(byArrayS==byOneS);
		System.out.println(byArrayS.getClass().isArray());
	
	}
}